/**
 * 《缙青年》电子期刊 - 工具函数库
 * 开发者：缙云公司—韩剑
 */

// 工具函数命名空间
const Utils = {
    
    // 本地存储管理
    storage: {
        /**
         * 保存数据到本地存储
         * @param {string} key 键名
         * @param {any} value 值
         */
        set(key, value) {
            try {
                const data = JSON.stringify(value);
                localStorage.setItem(key, data);
                return true;
            } catch (error) {
                console.error('保存到本地存储失败:', error);
                return false;
            }
        },

        /**
         * 从本地存储获取数据
         * @param {string} key 键名
         * @param {any} defaultValue 默认值
         * @returns {any} 存储的值或默认值
         */
        get(key, defaultValue = null) {
            try {
                const data = localStorage.getItem(key);
                return data ? JSON.parse(data) : defaultValue;
            } catch (error) {
                console.error('从本地存储读取失败:', error);
                return defaultValue;
            }
        },

        /**
         * 删除本地存储数据
         * @param {string} key 键名
         */
        remove(key) {
            try {
                localStorage.removeItem(key);
                return true;
            } catch (error) {
                console.error('删除本地存储失败:', error);
                return false;
            }
        },

        /**
         * 清空所有本地存储
         */
        clear() {
            try {
                localStorage.clear();
                return true;
            } catch (error) {
                console.error('清空本地存储失败:', error);
                return false;
            }
        }
    },

    // 导航管理
    navigation: {
        /**
         * 获取URL参数
         * @param {string} name 参数名
         * @returns {string|null} 参数值
         */
        getUrlParam(name) {
            const urlParams = new URLSearchParams(window.location.search);
            return urlParams.get(name);
        },

        /**
         * 设置URL参数
         * @param {string} name 参数名
         * @param {string} value 参数值
         */
        setUrlParam(name, value) {
            const url = new URL(window.location);
            url.searchParams.set(name, value);
            window.history.replaceState({}, '', url);
        },

        /**
         * 跳转到阅读器页面
         * @param {string} bookId 书籍ID
         * @param {number} page 页码
         */
        goToReader(bookId, page = 1) {
            const url = `reader.html?book=${encodeURIComponent(bookId)}&page=${page}`;
            window.location.href = url;
        },

        /**
         * 返回主页
         */
        goToHome() {
            window.location.href = 'index.html';
        }
    },

    // 响应式工具
    responsive: {
        /**
         * 检查是否为移动设备
         * @returns {boolean}
         */
        isMobile() {
            return window.innerWidth <= 768;
        },

        /**
         * 检查是否为触摸设备
         * @returns {boolean}
         */
        isTouchDevice() {
            return 'ontouchstart' in window || navigator.maxTouchPoints > 0;
        },

        /**
         * 获取设备像素比
         * @returns {number}
         */
        getDevicePixelRatio() {
            return window.devicePixelRatio || 1;
        },

        /**
         * 获取视口尺寸
         * @returns {Object} {width, height}
         */
        getViewportSize() {
            return {
                width: window.innerWidth,
                height: window.innerHeight
            };
        }
    },

    // DOM操作工具（兼容性增强）
    dom: {
        /**
         * 查询元素（兼容旧版浏览器）
         * @param {string} selector 选择器
         * @param {Element} parent 父元素
         * @returns {Element|null}
         */
        $(selector, parent = document) {
            if (parent.querySelector) {
                return parent.querySelector(selector);
            } else {
                // 降级到getElementById（仅支持ID选择器）
                if (selector.startsWith('#')) {
                    return document.getElementById(selector.slice(1));
                }
                return null;
            }
        },

        /**
         * 查询所有元素（兼容旧版浏览器）
         * @param {string} selector 选择器
         * @param {Element} parent 父元素
         * @returns {NodeList|Array}
         */
        $$(selector, parent = document) {
            if (parent.querySelectorAll) {
                return parent.querySelectorAll(selector);
            } else {
                // 降级处理
                if (selector.startsWith('.')) {
                    return document.getElementsByClassName(selector.slice(1));
                } else if (selector.startsWith('#')) {
                    const element = document.getElementById(selector.slice(1));
                    return element ? [element] : [];
                } else {
                    return document.getElementsByTagName(selector);
                }
            }
        },

        /**
         * 添加事件监听器（兼容旧版浏览器）
         * @param {Element} element 元素
         * @param {string} event 事件名
         * @param {Function} handler 处理函数
         * @param {Object} options 选项
         */
        on(element, event, handler, options = {}) {
            if (!element) return;

            if (element.addEventListener) {
                element.addEventListener(event, handler, options);
            } else if (element.attachEvent) {
                // IE8及以下版本
                element.attachEvent('on' + event, handler);
            } else {
                // 最后的降级方案
                element['on' + event] = handler;
            }
        },

        /**
         * 移除事件监听器（兼容旧版浏览器）
         * @param {Element} element 元素
         * @param {string} event 事件名
         * @param {Function} handler 处理函数
         */
        off(element, event, handler) {
            if (!element) return;

            if (element.removeEventListener) {
                element.removeEventListener(event, handler);
            } else if (element.detachEvent) {
                // IE8及以下版本
                element.detachEvent('on' + event, handler);
            } else {
                // 最后的降级方案
                element['on' + event] = null;
            }
        },

        /**
         * 显示元素
         * @param {Element} element 元素
         */
        show(element) {
            element.style.display = '';
            element.removeAttribute('hidden');
        },

        /**
         * 隐藏元素
         * @param {Element} element 元素
         */
        hide(element) {
            element.style.display = 'none';
        },

        /**
         * 切换元素显示状态
         * @param {Element} element 元素
         */
        toggle(element) {
            if (element.style.display === 'none') {
                this.show(element);
            } else {
                this.hide(element);
            }
        },

        /**
         * 添加CSS类（兼容旧版浏览器）
         * @param {Element} element 元素
         * @param {string} className 类名
         */
        addClass(element, className) {
            if (!element) return;

            if (element.classList) {
                element.classList.add(className);
            } else {
                // 降级方案
                const classes = element.className.split(' ');
                if (classes.indexOf(className) === -1) {
                    classes.push(className);
                    element.className = classes.join(' ').trim();
                }
            }
        },

        /**
         * 移除CSS类（兼容旧版浏览器）
         * @param {Element} element 元素
         * @param {string} className 类名
         */
        removeClass(element, className) {
            if (!element) return;

            if (element.classList) {
                element.classList.remove(className);
            } else {
                // 降级方案
                const classes = element.className.split(' ');
                const index = classes.indexOf(className);
                if (index !== -1) {
                    classes.splice(index, 1);
                    element.className = classes.join(' ').trim();
                }
            }
        },

        /**
         * 切换CSS类
         * @param {Element} element 元素
         * @param {string} className 类名
         */
        toggleClass(element, className) {
            element.classList.toggle(className);
        }
    },

    // 错误处理工具
    error: {
        /**
         * 显示错误提示
         * @param {string} title 错误标题
         * @param {string} message 错误消息
         * @param {Array} solutions 解决方案列表
         * @param {Function} onRetry 重试回调
         * @param {Function} onClose 关闭回调
         */
        show(title, message, solutions = [], onRetry = null, onClose = null) {
            const modal = Utils.dom.$('#errorModal');
            const titleEl = Utils.dom.$('#errorTitle');
            const messageEl = Utils.dom.$('#errorMessage');
            const retryBtn = Utils.dom.$('#errorRetryBtn');
            const closeBtn = Utils.dom.$('#errorCloseBtn');

            if (titleEl) titleEl.textContent = title;
            if (messageEl) messageEl.textContent = message;

            // 设置解决方案
            const solutionsEl = Utils.dom.$('#errorSolutions');
            if (solutionsEl && solutions.length > 0) {
                const ul = solutionsEl.querySelector('ul');
                if (ul) {
                    ul.innerHTML = solutions.map(solution => `<li>${solution}</li>`).join('');
                }
                Utils.dom.show(solutionsEl);
            } else if (solutionsEl) {
                Utils.dom.hide(solutionsEl);
            }

            // 设置按钮事件
            if (retryBtn) {
                retryBtn.onclick = () => {
                    this.hide();
                    if (onRetry) onRetry();
                };
            }

            if (closeBtn) {
                closeBtn.onclick = () => {
                    this.hide();
                    if (onClose) onClose();
                };
            }

            // 显示模态框
            if (modal) {
                Utils.dom.show(modal);
                Utils.dom.addClass(modal, 'show');
            }
        },

        /**
         * 隐藏错误提示
         */
        hide() {
            const modal = Utils.dom.$('#errorModal');
            if (modal) {
                Utils.dom.removeClass(modal, 'show');
                setTimeout(() => {
                    Utils.dom.hide(modal);
                }, 300);
            }
        }
    },

    // 格式化工具
    format: {
        /**
         * 格式化文件大小
         * @param {number} bytes 字节数
         * @returns {string} 格式化后的大小
         */
        fileSize(bytes) {
            if (bytes === 0) return '0 B';
            const k = 1024;
            const sizes = ['B', 'KB', 'MB', 'GB'];
            const i = Math.floor(Math.log(bytes) / Math.log(k));
            return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
        },

        /**
         * 格式化日期
         * @param {Date|string} date 日期
         * @returns {string} 格式化后的日期
         */
        date(date) {
            const d = new Date(date);
            return d.toLocaleDateString('zh-CN', {
                year: 'numeric',
                month: 'long',
                day: 'numeric'
            });
        }
    },

    // 防抖和节流
    debounce(func, wait, immediate = false) {
        let timeout;
        return function executedFunction(...args) {
            const later = () => {
                timeout = null;
                if (!immediate) func(...args);
            };
            const callNow = immediate && !timeout;
            clearTimeout(timeout);
            timeout = setTimeout(later, wait);
            if (callNow) func(...args);
        };
    },

    throttle(func, limit) {
        let inThrottle;
        return function(...args) {
            if (!inThrottle) {
                func.apply(this, args);
                inThrottle = true;
                setTimeout(() => inThrottle = false, limit);
            }
        };
    },

    // 网络请求工具（兼容性增强）
    http: {
        /**
         * GET请求（兼容旧版浏览器）
         * @param {string} url 请求URL
         * @param {Object} options 选项
         * @returns {Promise}
         */
        async get(url, options = {}) {
            if (typeof fetch !== 'undefined') {
                // 现代浏览器使用fetch
                const response = await fetch(url, {
                    method: 'GET',
                    ...options
                });

                if (!response.ok) {
                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
                }

                return response;
            } else {
                // 降级到XMLHttpRequest
                return new Promise((resolve, reject) => {
                    const xhr = new XMLHttpRequest();
                    xhr.open('GET', url);

                    // 设置请求头
                    if (options.headers) {
                        for (const key in options.headers) {
                            xhr.setRequestHeader(key, options.headers[key]);
                        }
                    }

                    xhr.onload = function() {
                        if (xhr.status >= 200 && xhr.status < 300) {
                            resolve({
                                ok: true,
                                status: xhr.status,
                                statusText: xhr.statusText,
                                text: () => Promise.resolve(xhr.responseText),
                                json: () => Promise.resolve(JSON.parse(xhr.responseText)),
                                arrayBuffer: () => Promise.resolve(xhr.response)
                            });
                        } else {
                            reject(new Error(`HTTP ${xhr.status}: ${xhr.statusText}`));
                        }
                    };

                    xhr.onerror = () => reject(new Error('Network error'));
                    xhr.send();
                });
            }
        }
    }
};

// 导出到全局
window.Utils = Utils;
